<?php

namespace App\Tools;


use Redis;

class RedisTool
{
    //redis实例化时静态变量
    public $redis = null;

    //Redis基础信息
    protected $options = [
        'host' => '127.0.0.1',
        'port' => 6379,
        'password' => '',
        'select' => 0,
        'timeout' => 0,
        'expire' => 0,
        'persistent' => false,
        'prefix' => '',
    ];


    public static $instance; //单例

    public static function instance($select = 0): RedisTool
    {
        if (is_null(self::$instance)) {
            self::$instance = new static($select);
        }
        return self::$instance;
    }


    public function __construct($select = 0)
    {
        if ($select > 0) {
            $this->options['select'] = $select;
        }
        //读取redis 配置
        $options = config('database.redis.cache');

        if (!empty($options)) {
            $this->options = array_merge($this->options, $options);
        }
        $this->redis = new Redis();
        $this->redis->connect($this->options['host'], $this->options['port'], $this->options['timeout']);

        if ('' !== $this->options['password']) {
            $this->redis->auth($this->options['password']);
        }

        if (0 !== $this->options['select']) {
            $this->redis->select($this->options['select']);
        }
    }

    /**
     * 获取Redis信息
     * @access public
     * @return Redis
     */
    public function getRedis(): Redis
    {
        return $this->redis;
    }

    /**
     * 获取实际的缓存标识
     * @access public
     * @param string $name 缓存名
     * @return string
     */
    protected function getCacheKey(string $name): string
    {
        return $this->options['prefix'] . $name;
    }

    /**
     * 搜索 RedisKey
     * @access public
     * @param $key
     * @return array
     */
    public function getSearchKeys($key): array
    {
        return $this->redis->keys('*' . $key . '*');
    }


    /**
     * 清除缓存
     * @access public
     * @param string|null $tag 标签名
     * @return boolean
     */
    public function clear(string $tag = null): bool
    {
        if ($tag) {
            $this->redis->del($this->redis->keys($this->getCacheKey($tag) . '*'));
            return true;
        }
        // 清除整个库
        return $this->redis->flushDB();
    }


    /**
     * redis 设置过期时间
     * @param $key
     * @param int|null $expire
     */
    public function setExpire($key, int $expire = null)
    {
        if ($expire && $expire > 0) {
            $this->redis->expire($key, $expire);
        }
    }

    //=========================================字符串操作=====================================================

    /**
     * 读取缓存
     * @access public
     * @param string $name 缓存变量名
     * @param mixed $default 默认值
     * @return mixed
     */
    public function get(string $name, $default = false)
    {
        $value = $this->redis->get($this->getCacheKey($name));
        if (empty($value)) {
            return $default;
        }
        $jsonData = json_decode($value, true);
        return (null === $jsonData) ? $value : $jsonData;
    }

    /**
     * 写入缓存
     * @access public
     * @param string $name 缓存变量名
     * @param mixed $value 存储数据
     * @param integer|null $expire 有效时间（秒）
     * @return boolean
     */
    public function set(string $name, $value, int $expire = null): bool
    {
        if (is_null($expire)) {
            $expire = $this->options['expire'];
        }

        $key = $this->getCacheKey($name);
        //对数组/对象数据进行缓存处理，保证数据完整性  byron sampson<xiaobo.sun@qq.com>
        $value = (is_object($value) || is_array($value)) ? json_encode($value) : $value;
        if (is_int($expire) && $expire) {
            $result = $this->redis->setex($key, $expire, $value);
        } else {
            $result = $this->redis->set($key, $value);
        }
        return $result;
    }

    /**
     * 自增缓存（针对数值缓存）
     * @access public
     * @param string $name 缓存变量名
     * @param int $step 步长
     * @return int
     */
    public function inc(string $name, int $step = 1): int
    {
        $key = $this->getCacheKey($name);
        return $this->redis->incrby($key, $step);
    }

    /**
     * 自减缓存（针对数值缓存）
     * @access public
     * @param string $name 缓存变量名
     * @param int $step 步长
     */
    public function dec(string $name, int $step = 1): int
    {
        $key = $this->getCacheKey($name);
        return $this->redis->decrby($key, $step);
    }

    /**
     * 删除缓存
     * @access public
     * @param string $name 缓存变量名
     * @return void
     */
    public function rm(string $name)
    {
        $this->redis->del($this->getCacheKey($name));
    }

    //=========================================字符串操作结束=====================================================

    //===============================================set 集合 =================================================

    /**
     * 向集合中添加一个或者多个元素
     * @param $name string
     * @param $value string
     * @param null $expire
     * @return bool
     */
    public function sAdd(string $name, string $value, $expire = null): bool
    {
        $prefixName = $this->getCacheKey($name);

        $res = $this->redis->sAdd($prefixName, $value);

        $this->setExpire($prefixName, $expire);
        if ($res) {
            return true;
        }
        return false;
    }

    /**
     * 获取集合 key 中的所有成员元素
     * @param $name
     * @return array
     */
    public function sMembers($name): array
    {
        return $this->redis->sMembers($this->getCacheKey($name));
    }

    /**
     * 获取集合里面的元素个数
     * @param $name
     * @return int
     */
    public function sCard($name): int
    {
        return $this->redis->sCard($this->getCacheKey($name));
    }

    /**
     * 获取并集
     * @param $name1
     * @param $name2
     * @return array
     */
    public function sUnion($name1, $name2): array
    {
        return $this->redis->sUnion($this->getCacheKey($name1), $this->getCacheKey($name2));
    }

    /**
     * 获取交集
     * @param $name1
     * @param $name2
     * @return array
     */
    public function sInter($name1, $name2): array
    {
        return $this->redis->sInter($this->getCacheKey($name1), $this->getCacheKey($name2));
    }

    /**
     * 获取差集
     * @param $name1
     * @param $name2
     * @return array
     */
    public function sDiff($name1, $name2): array
    {
        return $this->redis->sDiff($this->getCacheKey($name1), $this->getCacheKey($name2));
    }

    /**
     * 判断val元素是不是集合key的元素
     * @param $name
     * @param $value
     * @return bool
     */
    public function sIsMember($name, $value): bool
    {
        return $this->redis->sIsMember($this->getCacheKey($name), $value);
    }

    /**
     * 移除并返回集合中的随机一个元素
     * @param $name
     * @param $count
     * @return array|bool|mixed|string
     */
    public function sPop($name, $count)
    {
        return $this->redis->sPop($this->getCacheKey($name), $count);
    }

    /**
     * 移除并返回集合中的随机一个元素
     * @param $name
     * @param $value
     * @return int
     */
    public function sRem($name, $value): int
    {
        return $this->redis->sRem($this->getCacheKey($name), $value);
    }

    /**
     * 将val元素从key1集合中移动到key2集合
     * @param $name1
     * @param $name2
     * @param $value
     * @return bool
     */
    public function sMove($name1, $name2, $value): bool
    {
        return $this->redis->sMove($this->getCacheKey($name1), $this->getCacheKey($name2), $value);
    }

    //===============================================set 集合结束 ===============================================


    //===============================================set 有序集合 =================================================

    /**
     * 增加一个或多个元素，如果该元素已经存在，
     * 更新它的score值虽然有序集合有序，但它也是集合，不能重复元素，添加重复元素只会更新原有元素的score值
     * @param $name
     * @param $score
     * @param $expire
     * @param $value
     */
    public function zAdd($name, $score, $value, $expire = null)
    {
        $value = (is_object($value) || is_array($value)) ? json_encode($value) : $value;
        $this->redis->zAdd($this->getCacheKey($name), $score, $value);
        $this->setExpire($this->getCacheKey($name), $expire);
    }


    /**
     * @param $name
     * @param $minScore
     * @param $maxScore
     * @return int
     * @Author Niu
     * @Date 2022/3/1 18:31
     */
    public function zCount($name, $minScore, $maxScore): int
    {
        return $this->redis->zCount($this->getCacheKey($name), $minScore, $maxScore);
    }

    /**
     * @param $name
     * @return int
     * @Author Niu
     * @Date 2022/3/1 18:31
     */
    public function zCard($name): int
    {
        return $this->redis->zCard($this->getCacheKey($name));
    }

    /**
     * @param $name
     * @param $score
     * @param $value
     * @Author Niu
     * @Date 2022/3/1 18:31
     */
    public function zIncrBy($name, $score, $value)
    {
        $this->redis->zIncrBy($this->getCacheKey($name), $score, $value);
    }

    /**
     * @param $name
     * @param int $start
     * @param int $end
     * @param $withScore
     * @return array
     * @Author niuyongqiang@kungeek.com
     * @Date 2022/3/1 18:33
     */
    public function zRange($name, int $start = 0, int $end = -1, $withScore = null): array
    {
        return $this->redis->zRange($this->getCacheKey($name), $start, $end, $withScore);
    }

    /**
     * @param $name
     * @param int $start
     * @param int $end
     * @param $withScore
     * @return array
     * @Author Niu
     * @Date 2022/3/1 18:30
     */
    public function zRevRange($name, int $start = 0, int $end = -1, $withScore = null): array
    {
        return $this->redis->zRevRange($this->getCacheKey($name), $start, $end, $withScore);
    }

    /**
     * @param $key
     * @param $member
     * @return bool|float
     * @Author Niu
     * @Date 2022/3/1 18:31
     */
    public function zScore($key, $member)
    {
        return $this->redis->zScore($this->getCacheKey($key), $member);
    }

    /**
     * @param $key
     * @param $member
     * @return false|int
     * @Author Niu
     * @Date 2022/3/1 18:31
     */
    public function zRank($key, $member)
    {
        return $this->redis->zRank($this->getCacheKey($key), $member);
    }

    /**
     * @param $key
     * @param $member
     * @return false|int
     * @Author Niu
     * @Date 2022/3/1 18:30
     */
    public function zRevRank($key, $member)
    {
        return $this->redis->zRevRank($this->getCacheKey($key), $member);
    }

    /**
     * expireAt 用于以 UNIX 时间戳(unix timestamp)格式设置 key 的过期时间。key 过期后将不再可用
     * @param $key
     * @param $time
     * @return bool (1 设置成功 0设置失败)
     * @author Guofeng
     */
    public function expireAt($key, $time): bool
    {
        return $this->redis->Expireat($this->getCacheKey($key), $time);
    }

    /**
     * 删除集合中一个元素
     * @param $key
     * @param $member
     * @return int
     */
    public function zRem($key, $member): int
    {
        return $this->redis->zREM($this->getCacheKey($key), $member);
    }
    //===============================================set 有序集合结束 =================================================


    //===============================================hash表 =================================================

    /**
     * @param $name
     * @param $hashKey
     * @param $value
     * @param $expire
     * @return int
     * @Author Niu
     * @Date 2022/3/1 18:30
     */
    public function hSet($name, $hashKey, $value, $expire = null): int
    {

        if (is_null($expire)) {
            $expire = $this->options['expire'];
        }

        $key = $this->getCacheKey($name);
        //对数组/对象数据进行缓存处理，保证数据完整性  byron sampson<xiaobo.sun@qq.com>
        $value = (is_object($value) || is_array($value)) ? json_encode($value) : $value;
        $result = $this->redis->hSet($key, $hashKey, $value);
        $this->setExpire($key, $expire);
        return $result;
    }

    /**
     * 检查key是否存在
     * 返回值:
     * BOOL: 存在返回 true, 不存在返回 false
     * @param $name
     * @return bool
     */
    public function exists($name): bool
    {
        return $this->redis->exists($this->getCacheKey($name));
    }

    /**
     * 获得某哈希 key 的值.如果 hash 表不存在或对应的 key 不存在，返回 false
     * 返回值:
     * STRING ,如果 hash 表不存在或对应的 key 不存在，返回 false
     * @param $name
     * @param $hashKey
     * @param mixed $default 默认值
     * @return mixed|string
     */
    public function hGet($name, $hashKey, $default = false)
    {
        $value = $this->redis->hGet($this->getCacheKey($name), $hashKey);
        if (!$value) {
            return $default;
        }
        $jsonData = json_decode($value, true);
        // 检测是否为JSON数据 true 返回JSON解析数组, false返回源数据 byron sampson<xiaobo.sun@qq.com>
        return (null === $jsonData) ? $value : $jsonData;
    }

    /**
     * 给哈希表设置多个 key 的值
     * 返回值:
     * BOOL
     * 示例:
     * $redis->delete('user:1');
     * $redis->hMet('user:1', array('name' => 'Joe', 'salary' => 2000));
     * @param $name
     * @param $map
     * @Author wu wu jin
     * @Date 2021-08-20 15:00
     * @param integer|null $expire 有效时间（秒）
     */
    public function hMSet($name, $map, int $expire = null)
    {
        foreach ($map as &$value) {
            if (is_array($value) || is_object($value)) {
                $value = json_encode($value, JSON_UNESCAPED_UNICODE);
            }
        }
        $key = $this->getCacheKey($name);
        $this->redis->hMset($key, $map);
        $this->setExpire($key, $expire);
    }

    /**
     * 获得哈希表中多个 key 的值
     * $redis->delete('h');
     * $redis->hSet('h', 'field1', 'value1');
     * $redis->hSet('h', 'field2', 'value2');
     * $redis->hmGet('h', array('field1', 'field2'));
     * @param $name
     * @param $arr
     * @Author wu wu jin
     * @Date 2021-08-20 15:00
     * @return array
     */
    public function hMGet($name, $arr): array
    {
        return $this->redis->hMGet($this->getCacheKey($name), $arr);
    }

    /**
     * 哈表中 key 的数量
     * 返回值:
     * LONG 哈表中 key 的数量.如果 hash 表不存在，或者对应的 key 的值不是 hash 类型，返回 false
     * $redis->delete('h')
     * $redis->hSet('h', 'key1', 'hello');
     * $redis->hSet('h', 'key2', 'plop');
     * $redis->hLen('h');
     * @param $name
     * @return int
     */
    public function hLen($name): int
    {
        return $this->redis->hLen($this->getCacheKey($name));
    }

    /**
     * 删除一个哈希 key.如果 hash 表不存在或对应的 key 不存在，返回 false
     * 返回值:
     * BOOL: 成功返回 TRUE. 失败返回 FALSE
     * @param $name
     * @param $hashKey
     * @return bool|int
     */
    public function hDel($name, $hashKey)
    {
        return $this->redis->hDel($name, $hashKey);
    }

    /**
     * @param $name
     * @Author Niu
     * @Date 2022/3/1 18:29
     */
    public function hDelAll($name)
    {
        $this->redis->del($this->getCacheKey($name));
    }

    /**
     * 检查哈希 key是否存在
     * 返回值:
     * BOOL: 存在返回 true, 不存在返回 false
     * @param $name
     * @param $hashKey
     * @return bool
     */
    public function hExists($name, $hashKey): bool
    {
        return $this->redis->hExists($this->getCacheKey($name), $hashKey);
    }

    /**
     * 给哈希表中某 key 增加一个整数值 (原子操作)
     * 返回值:
     * LONG 增加后的值
     * @param $name
     * @param $hashKey
     * @param $intValue
     * @Author wu wu jin
     * @Date 2021-08-20 15:00
     * @return int
     */
    public function hIncrBy($name, $hashKey, $intValue): int
    {
        return $this->redis->hIncrBy($this->getCacheKey($name), $hashKey, $intValue);
    }

    /**
     * @param $name
     * @param $hashKey
     * @param $floatValue
     * @return float
     * @Author Niu
     * @Date 2022/3/1 18:30
     */
    public function hIncrByFloat($name, $hashKey, $floatValue): float
    {
        return $this->redis->hIncrByFloat($this->getCacheKey($name), $hashKey, $floatValue);
    }


    /**
     * 获得一个哈希表中所有的 key 和 value
     * @param $name
     * @return array
     */
    public function hGetAll($name): array
    {
        $data = $this->redis->hGetAll($this->getCacheKey($name));
        $res = [];
        foreach ($data as $key => $value) {
            $jsonData = json_decode($value, true);
            $res[$key] = (null === $jsonData) ? $value : $jsonData;
        }
        return $res;
    }




    //===============================================hash表结束 =================================================


    //===============================================List表 =================================================

    /**
     * Redis lPush 命令将一个或多个值插入到列表头部。
     * 如果 key 不存在，一个空列表会被创建并执行 lPush 操作。
     * 当 key 存在但不是列表类型时，返回一个错误。
     * （在Redis 2.4版本以前的 lPush 命令，都只接受单个 value 值。）
     * @param $name
     * @param $value
     * @Author wu wu jin
     * @Date 2021-08-20 15:00
     * @param int $timeOut
     */
    public function lPush($name, $value, int $timeOut = 0)
    {
        $value = (is_object($value) || is_array($value)) ? json_encode($value) : $value;
        $this->redis->lPush($this->getCacheKey($name), $value);
        $this->setExpire($this->getCacheKey($name), $timeOut);
    }

    /**
     * Redis rPush 命令用于将一个或多个值插入到列表的尾部(最右边)。
     * 如果列表不存在，一个空列表会被创建并执行 rPush 操作。
     * 当列表存在但不是列表类型时，返回一个错误。
     * （注意：在 Redis 2.4 版本以前的 rPush 命令，都只接受单个 value 值）。
     * @param string $name KEY名称
     * @param string $value 值
     * @param int $timeOut |num  过期时间
     */
    public function rPush(string $name, string $value, int $timeOut = 0)
    {
        $this->redis->rPush($this->getCacheKey($name), $value);
        $this->setExpire($this->getCacheKey($name), $timeOut);
    }


    /**
     * Redis lPop 命令用于移除并返回列表的第一个元素。
     * @param $name
     * @return mixed|string
     */
    public function lPop($name)
    {
        $value = $this->redis->lPop($this->getCacheKey($name));
        $jsonData = json_decode($value, true);
        // 检测是否为JSON数据 true 返回JSON解析数组, false返回源数据 byron sampson<xiaobo.sun@qq.com>
        return (null === $jsonData) ? $value : $jsonData;
    }

    /**
     * Redis rPop 命令用于移除并返回列表的最后一个元素。
     * @param $name
     * @return string
     */
    public function rPop($name): string
    {
        return $this->redis->rPop($this->getCacheKey($name));
    }


    /**
     * Redis lLen 命令用于返回列表的长度。
     * 如果列表 key 不存在，则 key 被解释为一个空列表，返回 0 。
     * 如果 key 不是列表类型，返回一个错误。
     * @param $name
     * @return int
     */
    public function lLen($name): int
    {
        return $this->redis->lLen($this->getCacheKey($name));
    }

    /**
     * * Redis lRange 返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。
     * 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
     *
     * 　　（1）超出范围的下标值不会引起错误。
     *
     * 　　（2）如果start下标比列表的最大下标end(lLen list减去1)还要大，或者start > stop，lRange返回一个空列表。
     *
     * 　　（3）如果stop下标比end下标还要大，Redis将stop的值设置为end。
     * @param $name
     * @param int $start
     * @param int $end
     * @Author wu wu jin
     * @Date 2021-08-20 15:00
     * @return array
     */
    public function lRange($name, int $start = 0, int $end = -1): array
    {
        $list = $this->redis->lRange($this->getCacheKey($name), $start, $end);
        $res = [];
        if ($list) {
            foreach ($list as $item) {
                $jsonData = json_decode($item, true);
                $value = (null === $jsonData) ? $item : $jsonData;
                $res[] = $value;
            }
        }
        return $res;
    }

    /**
     * Redis lRem 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素。
     *
     * 　　COUNT 的值可以是以下几种：
     *
     * count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
     * count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
     * count = 0 : 移除表中所有与 VALUE 相等的值。
     * @param $name
     * @param $value
     * @param $count
     * @return int
     */
    public function lRem($name, $value, $count): int
    {
        $value = (is_object($value) || is_array($value)) ? json_encode($value) : $value;
        return $this->redis->lRem($this->getCacheKey($name), $value, $count);
    }

    /**
     * Redis lSet 通过索引来设置元素的值。
     * 当索引参数超出范围，或对一个空列表进行 lSet 时，返回一个错误。
     * @param $name
     * @param $index
     * @param $value
     * @param $ex
     * @return bool
     */
    public function lSet($name, $index, $value, $ex): bool
    {
        $res = $this->redis->lSet($this->getCacheKey($name), $index, $value);
        if ($res) {
            $this->setExpire($this->getCacheKey($name), $ex);
        }
        return $res;

    }


    /**
     * Redis Ltrim 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。（下标 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推）。
     *
     * 　　（1）超出范围的下标值不会引起错误。
     *
     * 　　（2）如果start下标比列表的最大下标end(lLen list减去1)还要大，或者start > stop，LTRIM返回一个空列表(因为LTRIM已经将整个列表清空)。
     *
     * 　　（3）如果stop下标比end下标还要大，Redis将stop的值设置为end。
     *  $redis = new redis();
     * $redis -> connect('127.0.0.1',6379);
     * $redis -> flushAll();
     *
     * $redis -> lPush('favorite_fruit','cherry');
     * $redis -> lPush('favorite_fruit','apple');
     * $redis -> lPush('favorite_fruit','peach');
     * $redis -> lPush('favorite_fruit','grape');
     *
     * var_dump($redis -> lTrim('favorite_fruit',1,-1));
     * var_dump($redis -> lRange('favorite_fruit',0,-1));
     * //  array (size=3)
     * //      0 => string 'peach' (length=5)
     * //      1 => string 'apple' (length=5)
     * //      2 => string 'cherry' (length=6)
     *
     * var_dump($redis -> lTrim('favorite_fruit',1,10));   // end > list 的长度，那就将 stop 值设为 end
     * var_dump($redis -> lRange('favorite_fruit',0,-1));
     * //  array (size=2)
     * //      0 => string 'apple' (length=5)
     * //      1 => string 'cherry' (length=6)
     *
     * var_dump($redis -> lTrim('favorite_fruit',7,1));        // start > end 或 start > stop , 清空整个 list
     * var_dump($redis -> lRange('favorite_fruit',0,-1));     // 返回 array (size=0) empty
     * @param $name
     * @param $start
     * @param $end
     */
    public function lTrim($name, $start, $end)
    {
        $this->redis->lTrim($this->getCacheKey($name), $start, $end);
    }

    /**
     * Redis Lindex 命令用于通过索引获取列表中的元素。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
     * var_dump($redis -> lIndex('favorite_fruit',2));     // string 'apple'
     * @param $name
     * @param $index
     * @return String
     */
    public function lIndex($name, $index): ?string
    {
        $value = $this->redis->lIndex($this->getCacheKey($name), $index);
        if ($value) {
            $jsonData = json_decode($value, true);
            // 检测是否为JSON数据 true 返回JSON解析数组, false返回源数据 byron sampson<xiaobo.sun@qq.com>
            return (null === $jsonData) ? $value : $jsonData;
        }
        return $value;
    }

    /**
     * Redis lInsert 命令用于在列表的元素前或者后插入元素。
     * 当指定元素不存在于列表中时，不执行任何操作。 当列表不存在时，被视为空列表，不执行任何操作。
     * 如果 key 不是列表类型，返回一个错误。
     *
     * 返回值：如果命令执行成功，返回插入操作完成之后，列表的长度。
     * 如果没有找到指定元素 ，返回 -1 。
     * 如果 key 不存在或为空列表，返回 0 。
     * @param $name
     * @param string $pos
     * const AFTER                 = 'after';
     * const BEFORE                = 'before';
     * @param $pivot
     * @param $value
     */
    public function lInsert($name, string $pos = Redis::BEFORE, $pivot, $value)
    {
        $pivot = (is_object($pivot) || is_array($pivot)) ? json_encode($pivot) : $pivot;
        $value = (is_object($value) || is_array($value)) ? json_encode($value) : $value;
        $this->redis->lInsert($this->getCacheKey($name), $pos, $pivot, $value);
    }

    //================================= list 结束 =================================

    /**
     * 查看Redis key剩余过期时间
     * @Author Guofeng
     * @Date 2021-07-27 15:00
     * @param $redisKey
     * @return int
     */
    public function Ttl($redisKey): int
    {
        return $this->redis->ttl($redisKey);
    }

    /**
     * redis 设置锁
     * @param  $key
     * @param  $value
     * @param  $expire
     * @Author wu wu jin
     * @Date 2021-08-20 15:00
     * @return integer
     **/
    public function setNx($key, $value, $expire): int
    {
        return $this->redis->set($key, $value, ['nx', 'ex' => $expire]);
    }

}
